{
"cells": [
{
"cell_type": "markdown",
"id": "3f40677e",
"metadata": {},
"source": [
"# 高頻度グリッドトレーディング\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "b6dc63c7",
"metadata": {},
"source": [
"## 単純な高頻度グリッドトレーディング\n",
"\n",
"これは、ミッドプライスを中心にグリッド上に注文を投稿し続け、固定間隔と設定されたグリッド数を維持する高頻度バージョンのグリッドトレーディングです。"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "641721c6",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"from numba import njit, uint64, float64\n",
"from numba.typed import Dict\n",
"\n",
"from hftbacktest import BUY, SELL, GTX, LIMIT\n",
"\n",
"@njit\n",
"def gridtrading(hbt, recorder):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" grid_num = 20\n",
" max_position = 5\n",
" grid_interval = tick_size * 10\n",
" half_spread = tick_size * 20\n",
"\n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0:\n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
" \n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
" \n",
" mid_price = (best_bid + best_ask) / 2.0\n",
"\n",
" order_qty = 0.1 # np.round(notional_order_qty / mid_price / hbt.depth(asset_no).lot_size) * hbt.depth(asset_no).lot_size\n",
" \n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor((mid_price - half_spread) / grid_interval) * grid_interval\n",
" ask_price = np.ceil((mid_price + half_spread) / grid_interval) * grid_interval\n",
"\n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price): # position * mid_price < max_notional_position\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price): # position * mid_price > -max_notional_position\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "markdown",
"id": "86a0d5a1-e5c9-484a-b270-d5473f9122ca",
"metadata": {},
"source": [
"フィードデータファイルからフィードレイテンシを注文レイテンシとして使用する注文レイテンシを生成する方法については、[Order Latency Data](https://hftbacktest.readthedocs.io/en/latest/tutorials/Order%20Latency%20Data.html) を参照してください。"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "9ecfecc8",
"metadata": {},
"outputs": [],
"source": [
"from hftbacktest import BacktestAsset, ROIVectorMarketDepthBacktest, Recorder\n",
"\n",
"asset = (\n",
" BacktestAsset()\n",
" .data([\n",
" 'data/ethusdt_20221003.npz',\n",
" 'data/ethusdt_20221004.npz',\n",
" 'data/ethusdt_20221005.npz',\n",
" 'data/ethusdt_20221006.npz',\n",
" 'data/ethusdt_20221007.npz'\n",
" ])\n",
" .initial_snapshot('data/ethusdt_20221002_eod.npz')\n",
" .linear_asset(1.0) \n",
" .intp_order_latency([\n",
" 'latency/feed_latency_20221003.npz',\n",
" 'latency/feed_latency_20221004.npz',\n",
" 'latency/feed_latency_20221005.npz',\n",
" 'latency/feed_latency_20221006.npz',\n",
" 'latency/feed_latency_20221007.npz'\n",
" ])\n",
" .power_prob_queue_model(2.0) \n",
" .no_partial_fill_exchange()\n",
" .trading_value_fee_model(-0.00005, 0.0007)\n",
" .tick_size(0.01)\n",
" .lot_size(0.001)\n",
" .roi_lb(0.0) \n",
" .roi_ub(3000.0)\n",
")\n",
"hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
"recorder = Recorder(1, 5_000_000)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7ca98776",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 6min 5s, sys: 9.08 s, total: 6min 15s\n",
"Wall time: 6min 16s\n"
]
}
],
"source": [
"%%time\n",
"gridtrading(hbt, recorder.recorder)\n",
"\n",
"_ = hbt.close()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "b9b5797c-27ea-4ff8-a3c6-5b5af1e292d1",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2022-10-03 00:00:00 2022-10-07 23:59:50 18.265693 25.144025 0.082691 0.021906 9489.819672 127.266294 3.774836 0.00013 9140.288
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "4cbd9b92",
"metadata": {},
"source": [
"## スキューを伴う高頻度グリッドトレーディング\n",
"\n",
"ポジションベースのスキューを組み込むことで、戦略のリスク調整後のリターンを向上させることができます。"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "e643b0df",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def gridtrading(hbt, recorder, skew):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" grid_num = 20\n",
" max_position = 5\n",
" grid_interval = tick_size * 10\n",
" half_spread = tick_size * 20\n",
"\n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0:\n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
" \n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
" \n",
" mid_price = (best_bid + best_ask) / 2.0\n",
" \n",
" order_qty = 0.1 # np.round(notional_order_qty / mid_price / hbt.depth(asset_no).lot_size) * hbt.depth(asset_no).lot_size\n",
" \n",
" # The personalized price that considers skewing based on inventory risk is introduced, \n",
" # which is described in the well-known Stokov-Avalleneda market-making paper.\n",
" # https://math.nyu.edu/~avellane/HighFrequencyTrading.pdf\n",
" reservation_price = mid_price - skew * tick_size * position\n",
"\n",
" # Since our price is skewed, it may cross the spread. To ensure market making and avoid crossing the spread, \n",
" # limit the price to the best bid and best ask.\n",
" bid_price = np.minimum(reservation_price - half_spread, best_bid)\n",
" ask_price = np.maximum(reservation_price + half_spread, best_ask)\n",
"\n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
" ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price): # position * mid_price < max_notional_position\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price): # position * mid_price > -max_notional_position\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "markdown",
"id": "851322e3",
"metadata": {},
"source": [
"### 弱いスキュー"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "6022d9f0",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2022-10-03 00:00:00 2022-10-07 23:59:50 18.363916 25.321583 0.060482 0.014831 10563.644529 141.707178 4.077966 0.000085 9409.12
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "a1a26c28",
"metadata": {},
"source": [
"### 強いスキュー\n",
"強いスキューの下では、ポジションは弱いスキューの場合と比較してより制限されます。市場が急激に動くと、エクイティのスパイクが観察されることもあります。ただし、実際には注文レイテンシのためにこれが実現しない可能性があります。後で、注文レイテンシの影響を探り、実際の履歴注文レイテンシデータを使用する重要性を強調します。"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "f747552e",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2022-10-03 00:00:00 2022-10-07 23:59:50 27.282302 47.25453 0.042574 0.005391 11838.874048 158.842253 7.897853 0.000054 8270.01
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "d4ff955e",
"metadata": {},
"source": [
"## 複数の資産\n",
"\n",
"より良いパフォーマンスを達成するために、各資産に適したパラメータを見つける必要があるかもしれません。例として、ここでは単一のパラメータセットを使用して、複数の資産の組み合わせのパフォーマンスがどのようになるかを示します。"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "ab58d41d",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def gridtrading(hbt, recorder, half_spread, grid_interval, skew, order_qty):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" grid_num = 20\n",
" max_position = grid_num * order_qty\n",
" \n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0: \n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
"\n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
" \n",
" mid_price = (best_bid + best_ask) / 2.0\n",
"\n",
" normalized_position = position / order_qty\n",
"\n",
" # The personalized price that considers skewing based on inventory risk is introduced, \n",
" # which is described in the well-known Stokov-Avalleneda market-making paper.\n",
" # https://math.nyu.edu/~avellane/HighFrequencyTrading.pdf\n",
" reservation_price = mid_price - skew * normalized_position\n",
"\n",
" # Since our price is skewed, it may cross the spread. To ensure market making and avoid crossing the spread, \n",
" # limit the price to the best bid and best ask.\n",
" bid_price = np.minimum(reservation_price - half_spread, best_bid)\n",
" ask_price = np.maximum(reservation_price + half_spread, best_ask)\n",
"\n",
" # Ensures the grid interval aligns with the tick size, with the minimum set to the tick size.\n",
" grid_interval = max(np.round(grid_interval / tick_size) * tick_size, tick_size)\n",
"\n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
" ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price): # position * mid_price < max_notional_position\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price): # position * mid_price > -max_notional_position\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "85517083",
"metadata": {},
"outputs": [],
"source": [
"from hftbacktest import BUY_EVENT, SELL_EVENT\n",
"\n",
"latency_data = np.concatenate(\n",
" [np.load('latency/live_latency_{}.npz'.format(date))['data'] for date in range(20230701, 20230732)]\n",
")\n",
" \n",
"def backtest(args):\n",
" asset_name, asset_info = args\n",
"\n",
" # Obtains the mid-price of the assset to determine the order quantity.\n",
" snapshot = np.load('data/{}_20230630_eod.npz'.format(asset_name))['data']\n",
" best_bid = max(snapshot[snapshot['ev'] & BUY_EVENT == BUY_EVENT]['px'])\n",
" best_ask = min(snapshot[snapshot['ev'] & SELL_EVENT == SELL_EVENT]['px'])\n",
" mid_price = (best_bid + best_ask) / 2.0\n",
" \n",
" asset = (\n",
" BacktestAsset()\n",
" .data(['data/{}_{}.npz'.format(asset_name, date) for date in range(20230701, 20230732)])\n",
" .initial_snapshot('data/{}_20230630_eod.npz'.format(asset_name))\n",
" .linear_asset(1.0) \n",
" .intp_order_latency(latency_data)\n",
" .log_prob_queue_model2() \n",
" .no_partial_fill_exchange()\n",
" .trading_value_fee_model(-0.00005, 0.0007)\n",
" .tick_size(asset_info['tick_size'])\n",
" .lot_size(asset_info['lot_size'])\n",
" .roi_lb(0)\n",
" .roi_ub(mid_price * 5)\n",
" )\n",
" hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
" # Sets the order quantity to be equivalent to a notional value of $100.\n",
" order_qty = max(round((100 / mid_price) / asset_info['lot_size']), 1) * asset_info['lot_size']\n",
"\n",
" half_spread = mid_price * 0.0008\n",
" grid_interval = mid_price * 0.0008\n",
" skew = mid_price * 0.000025\n",
"\n",
" recorder = Recorder(1, 50_000_000)\n",
" \n",
" gridtrading(hbt, recorder.recorder, half_spread, grid_interval, skew, order_qty)\n",
"\n",
" hbt.close()\n",
"\n",
" recorder.to_npz('stats/gridtrading_{}.npz'.format(asset_name))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "59c50c74-2005-46b7-8318-9fb6bdc9a044",
"metadata": {},
"outputs": [],
"source": [
"%%capture\n",
"\n",
"import json\n",
"from multiprocessing import Pool\n",
"\n",
"with open('assets.json', 'r') as f:\n",
" assets = json.load(f)\n",
"\n",
"with Pool(16) as p:\n",
" print(p.map(backtest, list(assets.items())))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "01c1fe7a-1574-4706-9c84-97e1696a9108",
"metadata": {},
"outputs": [],
"source": [
"import polars as pl\n",
"from hftbacktest.stats import LinearAssetRecord\n",
"\n",
"equity_values = {}\n",
"for asset_name in assets.keys():\n",
" data = np.load('stats/gridtrading_{}.npz'.format(asset_name))['0']\n",
" stats = (\n",
" LinearAssetRecord(data)\n",
" .resample('5m')\n",
" .stats()\n",
" )\n",
"\n",
" equity = stats.entire.with_columns(\n",
" (pl.col('equity_wo_fee') - pl.col('fee')).alias('equity')\n",
" ).select(['timestamp', 'equity'])\n",
" equity_values[asset_name] = equity"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "3407726b-00eb-415f-86b6-8b2f05871767",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0, 0.5, 'Cumulative Returns (%)')"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from matplotlib import pyplot as plt\n",
"\n",
"fig = plt.figure()\n",
"fig.set_size_inches(10, 3)\n",
"\n",
"legend = []\n",
"net_equity = None\n",
"for i, equity in enumerate(list(equity_values.values())):\n",
" asset_number = i + 1\n",
" if net_equity is None:\n",
" net_equity = equity['equity'].clone()\n",
" else:\n",
" net_equity += equity['equity'].clone()\n",
"\n",
" if asset_number % 10 == 0:\n",
" # 2_000 is capital for each trading asset.\n",
" net_equity_df = pl.DataFrame({\n",
" 'cum_ret': (net_equity / asset_number) / 2_000 * 100,\n",
" 'timestamp': equity['timestamp']\n",
" })\n",
" net_equity_rs_df = net_equity_df.group_by_dynamic(\n",
" index_column='timestamp',\n",
" every='1d'\n",
" ).agg([\n",
" pl.col('cum_ret').last()\n",
" ])\n",
" pnl = net_equity_rs_df['cum_ret'].diff()\n",
" sr = pnl.mean() / pnl.std()\n",
" ann_sr = sr * np.sqrt(365)\n",
"\n",
" plt.plot(net_equity_df['timestamp'], net_equity_df['cum_ret'])\n",
" legend.append('{} assets, SR={:.2f} (Daily SR={:.2f})'.format(asset_number, ann_sr, sr))\n",
"\n",
"plt.legend(\n",
" legend,\n",
" loc='upper center', bbox_to_anchor=(0.5, -0.15),\n",
" fancybox=True, shadow=True, ncol=3\n",
")\n",
"\n",
"plt.grid()\n",
"plt.ylabel('Cumulative Returns (%)')"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.14"
}
},
"nbformat": 4,
"nbformat_minor": 5
}